/**
 *
 */
import Util;
import OpenApi;
import OpenApiUtil;
import EndpointUtil;

extends OpenApi;


init(config: OpenApi.Config){
  super(config);
  @signatureAlgorithm = 'v2';
  @endpointRule = 'regional';
  @endpointMap = {
    ap-northeast-1 = 'xrengine-daily.aliyuncs.com',
    ap-northeast-2-pop = 'xrengine-daily.aliyuncs.com',
    ap-south-1 = 'xrengine-daily.aliyuncs.com',
    ap-southeast-1 = 'xrengine-daily.aliyuncs.com',
    ap-southeast-2 = 'xrengine-daily.aliyuncs.com',
    ap-southeast-3 = 'xrengine-daily.aliyuncs.com',
    ap-southeast-5 = 'xrengine-daily.aliyuncs.com',
    cn-beijing = 'xrengine-daily.aliyuncs.com',
    cn-beijing-finance-1 = 'xrengine-daily.aliyuncs.com',
    cn-beijing-finance-pop = 'xrengine-daily.aliyuncs.com',
    cn-beijing-gov-1 = 'xrengine-daily.aliyuncs.com',
    cn-beijing-nu16-b01 = 'xrengine-daily.aliyuncs.com',
    cn-chengdu = 'xrengine-daily.aliyuncs.com',
    cn-edge-1 = 'xrengine-daily.aliyuncs.com',
    cn-fujian = 'xrengine-daily.aliyuncs.com',
    cn-haidian-cm12-c01 = 'xrengine-daily.aliyuncs.com',
    cn-hangzhou-bj-b01 = 'xrengine-daily.aliyuncs.com',
    cn-hangzhou-finance = 'xrengine-daily.aliyuncs.com',
    cn-hangzhou-internal-prod-1 = 'xrengine-daily.aliyuncs.com',
    cn-hangzhou-internal-test-1 = 'xrengine-daily.aliyuncs.com',
    cn-hangzhou-internal-test-2 = 'xrengine-daily.aliyuncs.com',
    cn-hangzhou-internal-test-3 = 'xrengine-daily.aliyuncs.com',
    cn-hangzhou-test-306 = 'xrengine-daily.aliyuncs.com',
    cn-hongkong = 'xrengine-daily.aliyuncs.com',
    cn-hongkong-finance-pop = 'xrengine-daily.aliyuncs.com',
    cn-huhehaote = 'xrengine-daily.aliyuncs.com',
    cn-huhehaote-nebula-1 = 'xrengine-daily.aliyuncs.com',
    cn-north-2-gov-1 = 'xrengine-daily.aliyuncs.com',
    cn-qingdao = 'xrengine-daily.aliyuncs.com',
    cn-qingdao-nebula = 'xrengine-daily.aliyuncs.com',
    cn-shanghai = 'xrengine-daily.aliyuncs.com',
    cn-shanghai-et15-b01 = 'xrengine-daily.aliyuncs.com',
    cn-shanghai-et2-b01 = 'xrengine-daily.aliyuncs.com',
    cn-shanghai-finance-1 = 'xrengine-daily.aliyuncs.com',
    cn-shanghai-inner = 'xrengine-daily.aliyuncs.com',
    cn-shanghai-internal-test-1 = 'xrengine-daily.aliyuncs.com',
    cn-shenzhen = 'xrengine-daily.aliyuncs.com',
    cn-shenzhen-finance-1 = 'xrengine-daily.aliyuncs.com',
    cn-shenzhen-inner = 'xrengine-daily.aliyuncs.com',
    cn-shenzhen-st4-d01 = 'xrengine-daily.aliyuncs.com',
    cn-shenzhen-su18-b01 = 'xrengine-daily.aliyuncs.com',
    cn-wuhan = 'xrengine-daily.aliyuncs.com',
    cn-wulanchabu = 'xrengine-daily.aliyuncs.com',
    cn-yushanfang = 'xrengine-daily.aliyuncs.com',
    cn-zhangbei = 'xrengine-daily.aliyuncs.com',
    cn-zhangbei-na61-b01 = 'xrengine-daily.aliyuncs.com',
    cn-zhangjiakou = 'xrengine-daily.aliyuncs.com',
    cn-zhangjiakou-na62-a01 = 'xrengine-daily.aliyuncs.com',
    cn-zhengzhou-nebula-1 = 'xrengine-daily.aliyuncs.com',
    eu-central-1 = 'xrengine-daily.aliyuncs.com',
    eu-west-1 = 'xrengine-daily.aliyuncs.com',
    eu-west-1-oxs = 'xrengine-daily.aliyuncs.com',
    me-east-1 = 'xrengine-daily.aliyuncs.com',
    rus-west-1-pop = 'xrengine-daily.aliyuncs.com',
    us-east-1 = 'xrengine-daily.aliyuncs.com',
    us-west-1 = 'xrengine-daily.aliyuncs.com',
  };

  checkConfig(config);
  @endpoint = getEndpoint('xrengine', @regionId, @endpointRule, @network, @suffix, @endpointMap, @endpoint);
}

function getEndpoint(productId: string, regionId: string, endpointRule: string, network: string, suffix: string, endpointMap: map[string]string, endpoint: string) throws: string{
  if (!Util.empty(endpoint)) {
    return endpoint;
  }
  
  if (!Util.isUnset(endpointMap) && !Util.empty(endpointMap[regionId])) {
    return endpointMap[regionId];
  }
  return EndpointUtil.getEndpointRules(productId, regionId, endpointRule, network, suffix);
}

model AddWhitelistRequest {
  aliyunUid?: string(name='AliyunUid'),
  remark?: string(name='Remark'),
}

model AddWhitelistResponseBody = {
  code?: string(name='Code'),
  errorName?: string(name='ErrorName'),
  httpCode?: int32(name='HttpCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model AddWhitelistResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: AddWhitelistResponseBody(name='body'),
}

async function addWhitelistWithOptions(request: AddWhitelistRequest, runtime: Util.RuntimeOptions): AddWhitelistResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.aliyunUid)) {
    body['AliyunUid'] = request.aliyunUid;
  }
  if (!Util.isUnset(request.remark)) {
    body['Remark'] = request.remark;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'AddWhitelist',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function addWhitelist(request: AddWhitelistRequest): AddWhitelistResponse {
  var runtime = new Util.RuntimeOptions{};
  return addWhitelistWithOptions(request, runtime);
}

model AuthUserRequest {
  jwtToken?: string(name='JwtToken'),
}

model AuthUserResponseBody = {
  code?: string(name='Code'),
  data?: {
    jwtToken?: string(name='JwtToken'),
    type?: string(name='Type'),
  }(name='Data'),
  errorName?: string(name='ErrorName'),
  httpCode?: int32(name='HttpCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model AuthUserResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: AuthUserResponseBody(name='body'),
}

async function authUserWithOptions(request: AuthUserRequest, runtime: Util.RuntimeOptions): AuthUserResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.jwtToken)) {
    query['JwtToken'] = request.jwtToken;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'AuthUser',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function authUser(request: AuthUserRequest): AuthUserResponse {
  var runtime = new Util.RuntimeOptions{};
  return authUserWithOptions(request, runtime);
}

model BatchCreateSvcMapBindRequest {
  jwtToken?: string(name='JwtToken'),
  mapIds?: [ long ](name='MapIds'),
  svcId?: long(name='SvcId'),
}

model BatchCreateSvcMapBindShrinkRequest {
  jwtToken?: string(name='JwtToken'),
  mapIdsShrink?: string(name='MapIds'),
  svcId?: long(name='SvcId'),
}

model BatchCreateSvcMapBindResponseBody = {
  code?: string(name='Code'),
  data?: boolean(name='Data'),
  errorName?: string(name='ErrorName'),
  httpCode?: int32(name='HttpCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model BatchCreateSvcMapBindResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: BatchCreateSvcMapBindResponseBody(name='body'),
}

async function batchCreateSvcMapBindWithOptions(tmpReq: BatchCreateSvcMapBindRequest, runtime: Util.RuntimeOptions): BatchCreateSvcMapBindResponse {
  Util.validateModel(tmpReq);
  var request = new BatchCreateSvcMapBindShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.mapIds)) {
    request.mapIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.mapIds, 'MapIds', 'json');
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.jwtToken)) {
    body['JwtToken'] = request.jwtToken;
  }
  if (!Util.isUnset(request.mapIdsShrink)) {
    body['MapIds'] = request.mapIdsShrink;
  }
  if (!Util.isUnset(request.svcId)) {
    body['SvcId'] = request.svcId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'BatchCreateSvcMapBind',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function batchCreateSvcMapBind(request: BatchCreateSvcMapBindRequest): BatchCreateSvcMapBindResponse {
  var runtime = new Util.RuntimeOptions{};
  return batchCreateSvcMapBindWithOptions(request, runtime);
}

model BatchDeleteSvcMapBindRequest {
  ids?: [ long ](name='Ids'),
  jwtToken?: string(name='JwtToken'),
}

model BatchDeleteSvcMapBindShrinkRequest {
  idsShrink?: string(name='Ids'),
  jwtToken?: string(name='JwtToken'),
}

model BatchDeleteSvcMapBindResponseBody = {
  code?: string(name='Code'),
  data?: boolean(name='Data'),
  errorName?: string(name='ErrorName'),
  httpCode?: int32(name='HttpCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model BatchDeleteSvcMapBindResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: BatchDeleteSvcMapBindResponseBody(name='body'),
}

async function batchDeleteSvcMapBindWithOptions(tmpReq: BatchDeleteSvcMapBindRequest, runtime: Util.RuntimeOptions): BatchDeleteSvcMapBindResponse {
  Util.validateModel(tmpReq);
  var request = new BatchDeleteSvcMapBindShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.ids)) {
    request.idsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.ids, 'Ids', 'json');
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.idsShrink)) {
    body['Ids'] = request.idsShrink;
  }
  if (!Util.isUnset(request.jwtToken)) {
    body['JwtToken'] = request.jwtToken;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'BatchDeleteSvcMapBind',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function batchDeleteSvcMapBind(request: BatchDeleteSvcMapBindRequest): BatchDeleteSvcMapBindResponse {
  var runtime = new Util.RuntimeOptions{};
  return batchDeleteSvcMapBindWithOptions(request, runtime);
}

model BuildProjectRequest {
  jwtToken?: string(name='JwtToken'),
  projectId?: string(name='ProjectId'),
  videoName?: string(name='VideoName'),
}

model BuildProjectResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model BuildProjectResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: BuildProjectResponseBody(name='body'),
}

async function buildProjectWithOptions(request: BuildProjectRequest, runtime: Util.RuntimeOptions): BuildProjectResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.jwtToken)) {
    query['JwtToken'] = request.jwtToken;
  }
  if (!Util.isUnset(request.projectId)) {
    query['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.videoName)) {
    query['VideoName'] = request.videoName;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'BuildProject',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function buildProject(request: BuildProjectRequest): BuildProjectResponse {
  var runtime = new Util.RuntimeOptions{};
  return buildProjectWithOptions(request, runtime);
}

model CreateLocationServiceRequest {
  appId?: string(name='AppId'),
  imageId?: long(name='ImageId'),
  jwtToken?: string(name='JwtToken'),
  name?: string(name='Name'),
  note?: string(name='Note'),
  qps?: long(name='Qps'),
}

model CreateLocationServiceResponseBody = {
  code?: string(name='Code'),
  data?: boolean(name='Data'),
  errorName?: string(name='ErrorName'),
  httpCode?: int32(name='HttpCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CreateLocationServiceResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreateLocationServiceResponseBody(name='body'),
}

async function createLocationServiceWithOptions(request: CreateLocationServiceRequest, runtime: Util.RuntimeOptions): CreateLocationServiceResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.appId)) {
    body['AppId'] = request.appId;
  }
  if (!Util.isUnset(request.imageId)) {
    body['ImageId'] = request.imageId;
  }
  if (!Util.isUnset(request.jwtToken)) {
    body['JwtToken'] = request.jwtToken;
  }
  if (!Util.isUnset(request.name)) {
    body['Name'] = request.name;
  }
  if (!Util.isUnset(request.note)) {
    body['Note'] = request.note;
  }
  if (!Util.isUnset(request.qps)) {
    body['Qps'] = request.qps;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'CreateLocationService',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createLocationService(request: CreateLocationServiceRequest): CreateLocationServiceResponse {
  var runtime = new Util.RuntimeOptions{};
  return createLocationServiceWithOptions(request, runtime);
}

model CreateProjectRequest {
  autoBuild?: boolean(name='AutoBuild'),
  dependencies?: string(name='Dependencies'),
  gender?: string(name='Gender'),
  height?: double(name='Height'),
  intro?: string(name='Intro'),
  jwtToken?: string(name='JwtToken'),
  mapUuid?: string(name='MapUuid'),
  method?: string(name='Method'),
  mode?: string(name='Mode'),
  title?: string(name='Title'),
  tryOnParams?: {
    clothIds?: [ long ](name='ClothIds'),
    clothInfos?: [ 
      {
        id?: long(name='Id'),
        size?: string(name='Size'),
        status?: string(name='Status'),
      }
    ](name='ClothInfos'),
  }(name='TryOnParams'),
  type?: string(name='Type'),
  weight?: double(name='Weight'),
}

model CreateProjectShrinkRequest {
  autoBuild?: boolean(name='AutoBuild'),
  dependencies?: string(name='Dependencies'),
  gender?: string(name='Gender'),
  height?: double(name='Height'),
  intro?: string(name='Intro'),
  jwtToken?: string(name='JwtToken'),
  mapUuid?: string(name='MapUuid'),
  method?: string(name='Method'),
  mode?: string(name='Mode'),
  title?: string(name='Title'),
  tryOnParamsShrink?: string(name='TryOnParams'),
  type?: string(name='Type'),
  weight?: double(name='Weight'),
}

model CreateProjectResponseBody = {
  code?: string(name='Code'),
  data?: {
    createMode?: string(name='CreateMode'),
    createTime?: string(name='CreateTime'),
    dataset?: {
      createTime?: string(name='CreateTime'),
      id?: string(name='Id'),
      modifiedTime?: string(name='ModifiedTime'),
      ossKey?: string(name='OssKey'),
      policy?: {
        accessId?: string(name='AccessId'),
        dir?: string(name='Dir'),
        expire?: string(name='Expire'),
        host?: string(name='Host'),
        policy?: string(name='Policy'),
        signature?: string(name='Signature'),
      }(name='Policy'),
    }(name='Dataset'),
    id?: string(name='Id'),
    intro?: string(name='Intro'),
    method?: string(name='Method'),
    modifiedTime?: string(name='ModifiedTime'),
    source?: {
      ossKey?: string(name='OssKey'),
      policy?: {
        accessId?: string(name='AccessId'),
        dir?: string(name='Dir'),
        expire?: string(name='Expire'),
        host?: string(name='Host'),
        policy?: string(name='Policy'),
        signature?: string(name='Signature'),
      }(name='Policy'),
    }(name='Source'),
    status?: string(name='Status'),
    title?: string(name='Title'),
    type?: string(name='Type'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CreateProjectResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreateProjectResponseBody(name='body'),
}

async function createProjectWithOptions(tmpReq: CreateProjectRequest, runtime: Util.RuntimeOptions): CreateProjectResponse {
  Util.validateModel(tmpReq);
  var request = new CreateProjectShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.tryOnParams)) {
    request.tryOnParamsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.tryOnParams, 'TryOnParams', 'json');
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.autoBuild)) {
    body['AutoBuild'] = request.autoBuild;
  }
  if (!Util.isUnset(request.dependencies)) {
    body['Dependencies'] = request.dependencies;
  }
  if (!Util.isUnset(request.gender)) {
    body['Gender'] = request.gender;
  }
  if (!Util.isUnset(request.height)) {
    body['Height'] = request.height;
  }
  if (!Util.isUnset(request.intro)) {
    body['Intro'] = request.intro;
  }
  if (!Util.isUnset(request.jwtToken)) {
    body['JwtToken'] = request.jwtToken;
  }
  if (!Util.isUnset(request.mapUuid)) {
    body['MapUuid'] = request.mapUuid;
  }
  if (!Util.isUnset(request.method)) {
    body['Method'] = request.method;
  }
  if (!Util.isUnset(request.mode)) {
    body['Mode'] = request.mode;
  }
  if (!Util.isUnset(request.title)) {
    body['Title'] = request.title;
  }
  if (!Util.isUnset(request.tryOnParamsShrink)) {
    body['TryOnParams'] = request.tryOnParamsShrink;
  }
  if (!Util.isUnset(request.type)) {
    body['Type'] = request.type;
  }
  if (!Util.isUnset(request.weight)) {
    body['Weight'] = request.weight;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'CreateProject',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createProject(request: CreateProjectRequest): CreateProjectResponse {
  var runtime = new Util.RuntimeOptions{};
  return createProjectWithOptions(request, runtime);
}

model CreateSourcePolicyRequest {
  jwtToken?: string(name='JwtToken'),
  ossKey?: string(name='OssKey'),
}

model CreateSourcePolicyResponseBody = {
  code?: string(name='Code'),
  data?: {
    accessId?: string(name='AccessId'),
    dir?: string(name='Dir'),
    expire?: string(name='Expire'),
    host?: string(name='Host'),
    policy?: string(name='Policy'),
    signature?: string(name='Signature'),
  }(name='Data'),
  errorName?: string(name='ErrorName'),
  httpCode?: int32(name='HttpCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CreateSourcePolicyResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreateSourcePolicyResponseBody(name='body'),
}

async function createSourcePolicyWithOptions(request: CreateSourcePolicyRequest, runtime: Util.RuntimeOptions): CreateSourcePolicyResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.jwtToken)) {
    query['JwtToken'] = request.jwtToken;
  }
  if (!Util.isUnset(request.ossKey)) {
    query['OssKey'] = request.ossKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateSourcePolicy',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createSourcePolicy(request: CreateSourcePolicyRequest): CreateSourcePolicyResponse {
  var runtime = new Util.RuntimeOptions{};
  return createSourcePolicyWithOptions(request, runtime);
}

model DeleteProjectRequest {
  jwtToken?: string(name='JwtToken'),
  projectId?: string(name='ProjectId'),
}

model DeleteProjectResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model DeleteProjectResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DeleteProjectResponseBody(name='body'),
}

async function deleteProjectWithOptions(request: DeleteProjectRequest, runtime: Util.RuntimeOptions): DeleteProjectResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.jwtToken)) {
    query['JwtToken'] = request.jwtToken;
  }
  if (!Util.isUnset(request.projectId)) {
    query['ProjectId'] = request.projectId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteProject',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteProject(request: DeleteProjectRequest): DeleteProjectResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteProjectWithOptions(request, runtime);
}

model DeleteSourceFileRequest {
  fileId?: string(name='FileId'),
  jwtToken?: string(name='JwtToken'),
}

model DeleteSourceFileResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model DeleteSourceFileResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DeleteSourceFileResponseBody(name='body'),
}

async function deleteSourceFileWithOptions(request: DeleteSourceFileRequest, runtime: Util.RuntimeOptions): DeleteSourceFileResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.fileId)) {
    query['FileId'] = request.fileId;
  }
  if (!Util.isUnset(request.jwtToken)) {
    query['JwtToken'] = request.jwtToken;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteSourceFile',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteSourceFile(request: DeleteSourceFileRequest): DeleteSourceFileResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteSourceFileWithOptions(request, runtime);
}

model DeployLocationTreeRequest {
  forceUpdate?: boolean(name='ForceUpdate'),
  jwtToken?: string(name='JwtToken'),
  svcId?: long(name='SvcId'),
}

model DeployLocationTreeResponseBody = {
  code?: string(name='Code'),
  data?: boolean(name='Data'),
  errorName?: string(name='ErrorName'),
  httpCode?: int32(name='HttpCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model DeployLocationTreeResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DeployLocationTreeResponseBody(name='body'),
}

async function deployLocationTreeWithOptions(request: DeployLocationTreeRequest, runtime: Util.RuntimeOptions): DeployLocationTreeResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.forceUpdate)) {
    body['ForceUpdate'] = request.forceUpdate;
  }
  if (!Util.isUnset(request.jwtToken)) {
    body['JwtToken'] = request.jwtToken;
  }
  if (!Util.isUnset(request.svcId)) {
    body['SvcId'] = request.svcId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DeployLocationTree',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deployLocationTree(request: DeployLocationTreeRequest): DeployLocationTreeResponse {
  var runtime = new Util.RuntimeOptions{};
  return deployLocationTreeWithOptions(request, runtime);
}

model FindSvcMapBindRequest {
  current?: int32(name='Current'),
  jwtToken?: string(name='JwtToken'),
  size?: int32(name='Size'),
  sort?: string(name='Sort'),
  sortField?: string(name='SortField'),
  svcId?: long(name='SvcId'),
}

model FindSvcMapBindResponseBody = {
  code?: string(name='Code'),
  current?: int32(name='Current'),
  data?: map[string]any(name='Data'),
  errorName?: string(name='ErrorName'),
  httpCode?: int32(name='HttpCode'),
  message?: string(name='Message'),
  pages?: int32(name='Pages'),
  requestId?: string(name='RequestId'),
  size?: int32(name='Size'),
  success?: boolean(name='Success'),
  total?: int32(name='Total'),
}

model FindSvcMapBindResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: FindSvcMapBindResponseBody(name='body'),
}

async function findSvcMapBindWithOptions(request: FindSvcMapBindRequest, runtime: Util.RuntimeOptions): FindSvcMapBindResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.current)) {
    body['Current'] = request.current;
  }
  if (!Util.isUnset(request.jwtToken)) {
    body['JwtToken'] = request.jwtToken;
  }
  if (!Util.isUnset(request.size)) {
    body['Size'] = request.size;
  }
  if (!Util.isUnset(request.sort)) {
    body['Sort'] = request.sort;
  }
  if (!Util.isUnset(request.sortField)) {
    body['SortField'] = request.sortField;
  }
  if (!Util.isUnset(request.svcId)) {
    body['SvcId'] = request.svcId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'FindSvcMapBind',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function findSvcMapBind(request: FindSvcMapBindRequest): FindSvcMapBindResponse {
  var runtime = new Util.RuntimeOptions{};
  return findSvcMapBindWithOptions(request, runtime);
}

model GetArEditCommonMaterialRequest {
  jwtToken?: string(name='JwtToken'),
}

model GetArEditCommonMaterialResponseBody = {
  code?: string(name='Code'),
  data?: {
    accessKeyId?: string(name='AccessKeyId'),
    accessKeySecret?: string(name='AccessKeySecret'),
    expiration?: long(name='Expiration'),
    ossBucket?: string(name='OssBucket'),
    ossPath?: string(name='OssPath'),
    ossRegion?: string(name='OssRegion'),
    securityToken?: string(name='SecurityToken'),
  }(name='Data'),
  errorName?: string(name='ErrorName'),
  httpCode?: int32(name='HttpCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetArEditCommonMaterialResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetArEditCommonMaterialResponseBody(name='body'),
}

async function getArEditCommonMaterialWithOptions(request: GetArEditCommonMaterialRequest, runtime: Util.RuntimeOptions): GetArEditCommonMaterialResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.jwtToken)) {
    body['JwtToken'] = request.jwtToken;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetArEditCommonMaterial',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getArEditCommonMaterial(request: GetArEditCommonMaterialRequest): GetArEditCommonMaterialResponse {
  var runtime = new Util.RuntimeOptions{};
  return getArEditCommonMaterialWithOptions(request, runtime);
}

model GetArEditStsAuthRequest {
  jwtToken?: string(name='JwtToken'),
  mapId?: long(name='MapId'),
}

model GetArEditStsAuthResponseBody = {
  code?: string(name='Code'),
  data?: {
    accessKeyId?: string(name='AccessKeyId'),
    accessKeySecret?: string(name='AccessKeySecret'),
    editPath?: string(name='EditPath'),
    expiration?: long(name='Expiration'),
    map3DPath?: string(name='Map3DPath'),
    ossBucket?: string(name='OssBucket'),
    ossRegion?: string(name='OssRegion'),
    publishPath?: string(name='PublishPath'),
    securityToken?: string(name='SecurityToken'),
  }(name='Data'),
  errorName?: string(name='ErrorName'),
  httpCode?: int32(name='HttpCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetArEditStsAuthResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetArEditStsAuthResponseBody(name='body'),
}

async function getArEditStsAuthWithOptions(request: GetArEditStsAuthRequest, runtime: Util.RuntimeOptions): GetArEditStsAuthResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.jwtToken)) {
    body['JwtToken'] = request.jwtToken;
  }
  if (!Util.isUnset(request.mapId)) {
    body['MapId'] = request.mapId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetArEditStsAuth',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getArEditStsAuth(request: GetArEditStsAuthRequest): GetArEditStsAuthResponse {
  var runtime = new Util.RuntimeOptions{};
  return getArEditStsAuthWithOptions(request, runtime);
}

model GetArEditUgcMaterialRequest {
  jwtToken?: string(name='JwtToken'),
  mapId?: long(name='MapId'),
}

model GetArEditUgcMaterialResponseBody = {
  code?: string(name='Code'),
  data?: {
    accessKeyId?: string(name='AccessKeyId'),
    accessKeySecret?: string(name='AccessKeySecret'),
    expiration?: long(name='Expiration'),
    ossBucket?: string(name='OssBucket'),
    ossPath?: string(name='OssPath'),
    ossRegion?: string(name='OssRegion'),
    securityToken?: string(name='SecurityToken'),
  }(name='Data'),
  errorName?: string(name='ErrorName'),
  httpCode?: int32(name='HttpCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetArEditUgcMaterialResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetArEditUgcMaterialResponseBody(name='body'),
}

async function getArEditUgcMaterialWithOptions(request: GetArEditUgcMaterialRequest, runtime: Util.RuntimeOptions): GetArEditUgcMaterialResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.jwtToken)) {
    body['JwtToken'] = request.jwtToken;
  }
  if (!Util.isUnset(request.mapId)) {
    body['MapId'] = request.mapId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetArEditUgcMaterial',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getArEditUgcMaterial(request: GetArEditUgcMaterialRequest): GetArEditUgcMaterialResponse {
  var runtime = new Util.RuntimeOptions{};
  return getArEditUgcMaterialWithOptions(request, runtime);
}

model GetProjectDatasetRequest {
  jwtToken?: string(name='JwtToken'),
  ossKey?: string(name='OssKey'),
}

model GetProjectDatasetResponseBody = {
  code?: string(name='Code'),
  data?: {
    createMode?: string(name='CreateMode'),
    createTime?: string(name='CreateTime'),
    dataset?: {
      coverUrl?: string(name='CoverUrl'),
      createTime?: string(name='CreateTime'),
      id?: string(name='Id'),
      modelUrl?: string(name='ModelUrl'),
      modifiedTime?: string(name='ModifiedTime'),
      originResultUrl?: string(name='OriginResultUrl'),
      ossKey?: string(name='OssKey'),
      poseUrl?: string(name='PoseUrl'),
      previewUrl?: string(name='PreviewUrl'),
    }(name='Dataset'),
    id?: string(name='Id'),
    intro?: string(name='Intro'),
    modifiedTime?: string(name='ModifiedTime'),
    status?: string(name='Status'),
    title?: string(name='Title'),
    type?: string(name='Type'),
    bizUsage?: string(name='bizUsage'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetProjectDatasetResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetProjectDatasetResponseBody(name='body'),
}

async function getProjectDatasetWithOptions(request: GetProjectDatasetRequest, runtime: Util.RuntimeOptions): GetProjectDatasetResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.jwtToken)) {
    query['JwtToken'] = request.jwtToken;
  }
  if (!Util.isUnset(request.ossKey)) {
    query['OssKey'] = request.ossKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetProjectDataset',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getProjectDataset(request: GetProjectDatasetRequest): GetProjectDatasetResponse {
  var runtime = new Util.RuntimeOptions{};
  return getProjectDatasetWithOptions(request, runtime);
}

model ListAreaMapRequest {
  current?: int32(name='Current'),
  jwtToken?: string(name='JwtToken'),
  size?: int32(name='Size'),
  sort?: string(name='Sort'),
  sortField?: string(name='SortField'),
}

model ListAreaMapResponseBody = {
  code?: string(name='Code'),
  current?: int32(name='Current'),
  data?: map[string]any(name='Data'),
  errorName?: string(name='ErrorName'),
  httpCode?: int32(name='HttpCode'),
  message?: string(name='Message'),
  pages?: int32(name='Pages'),
  requestId?: string(name='RequestId'),
  size?: int32(name='Size'),
  success?: boolean(name='Success'),
  total?: int32(name='Total'),
}

model ListAreaMapResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ListAreaMapResponseBody(name='body'),
}

async function listAreaMapWithOptions(request: ListAreaMapRequest, runtime: Util.RuntimeOptions): ListAreaMapResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.current)) {
    body['Current'] = request.current;
  }
  if (!Util.isUnset(request.jwtToken)) {
    body['JwtToken'] = request.jwtToken;
  }
  if (!Util.isUnset(request.size)) {
    body['Size'] = request.size;
  }
  if (!Util.isUnset(request.sort)) {
    body['Sort'] = request.sort;
  }
  if (!Util.isUnset(request.sortField)) {
    body['SortField'] = request.sortField;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ListAreaMap',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listAreaMap(request: ListAreaMapRequest): ListAreaMapResponse {
  var runtime = new Util.RuntimeOptions{};
  return listAreaMapWithOptions(request, runtime);
}

model ListClothTypesResponseBody = {
  code?: string(name='Code'),
  data?: [ 
    {
      name?: string(name='Name'),
      type?: string(name='Type'),
    }
  ](name='Data'),
  errorName?: string(name='ErrorName'),
  httpCode?: int32(name='HttpCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ListClothTypesResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ListClothTypesResponseBody(name='body'),
}

async function listClothTypesWithOptions(runtime: Util.RuntimeOptions): ListClothTypesResponse {
  var req = new OpenApi.OpenApiRequest{};
  var params = new OpenApi.Params{
    action = 'ListClothTypes',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listClothTypes(): ListClothTypesResponse {
  var runtime = new Util.RuntimeOptions{};
  return listClothTypesWithOptions(runtime);
}

model ListClothesRequest {
  categories?: [ long ](name='Categories'),
  clothSize?: string(name='ClothSize'),
  current?: int32(name='Current'),
  jwtToken?: string(name='JwtToken'),
  name?: string(name='Name'),
  size?: int32(name='Size'),
  type?: string(name='Type'),
}

model ListClothesShrinkRequest {
  categoriesShrink?: string(name='Categories'),
  clothSize?: string(name='ClothSize'),
  current?: int32(name='Current'),
  jwtToken?: string(name='JwtToken'),
  name?: string(name='Name'),
  size?: int32(name='Size'),
  type?: string(name='Type'),
}

model ListClothesResponseBody = {
  code?: string(name='Code'),
  current?: int32(name='Current'),
  data?: [ 
    {
      coverUrl?: string(name='CoverUrl'),
      createTime?: string(name='CreateTime'),
      id?: string(name='Id'),
      modifiedTime?: string(name='ModifiedTime'),
      name?: string(name='Name'),
      ossKey?: string(name='OssKey'),
      part?: string(name='Part'),
      size?: string(name='Size'),
      status?: map[string]string(name='Status'),
      type?: string(name='Type'),
    }
  ](name='Data'),
  errorName?: string(name='ErrorName'),
  httpCode?: int32(name='HttpCode'),
  message?: string(name='Message'),
  pages?: int32(name='Pages'),
  requestId?: string(name='RequestId'),
  size?: int32(name='Size'),
  success?: boolean(name='Success'),
  total?: int32(name='Total'),
}

model ListClothesResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ListClothesResponseBody(name='body'),
}

async function listClothesWithOptions(tmpReq: ListClothesRequest, runtime: Util.RuntimeOptions): ListClothesResponse {
  Util.validateModel(tmpReq);
  var request = new ListClothesShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.categories)) {
    request.categoriesShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.categories, 'Categories', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.categoriesShrink)) {
    query['Categories'] = request.categoriesShrink;
  }
  if (!Util.isUnset(request.clothSize)) {
    query['ClothSize'] = request.clothSize;
  }
  if (!Util.isUnset(request.jwtToken)) {
    query['JwtToken'] = request.jwtToken;
  }
  if (!Util.isUnset(request.name)) {
    query['Name'] = request.name;
  }
  if (!Util.isUnset(request.type)) {
    query['Type'] = request.type;
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.current)) {
    body['Current'] = request.current;
  }
  if (!Util.isUnset(request.size)) {
    body['Size'] = request.size;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ListClothes',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listClothes(request: ListClothesRequest): ListClothesResponse {
  var runtime = new Util.RuntimeOptions{};
  return listClothesWithOptions(request, runtime);
}

model ListHdrResponseBody = {
  code?: string(name='Code'),
  data?: [ 
    {
      name?: string(name='Name'),
      path?: string(name='Path'),
    }
  ](name='Data'),
  errorName?: string(name='ErrorName'),
  httpCode?: int32(name='HttpCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ListHdrResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ListHdrResponseBody(name='body'),
}

async function listHdrWithOptions(runtime: Util.RuntimeOptions): ListHdrResponse {
  var req = new OpenApi.OpenApiRequest{};
  var params = new OpenApi.Params{
    action = 'ListHdr',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listHdr(): ListHdrResponse {
  var runtime = new Util.RuntimeOptions{};
  return listHdrWithOptions(runtime);
}

model ListLocationPaiImageRequest {
  current?: int32(name='Current'),
  jwtToken?: string(name='JwtToken'),
  size?: int32(name='Size'),
  sort?: string(name='Sort'),
  sortField?: string(name='SortField'),
}

model ListLocationPaiImageResponseBody = {
  code?: string(name='Code'),
  current?: int32(name='Current'),
  data?: map[string]any(name='Data'),
  errorName?: string(name='ErrorName'),
  httpCode?: int32(name='HttpCode'),
  message?: string(name='Message'),
  pages?: int32(name='Pages'),
  requestId?: string(name='RequestId'),
  size?: int32(name='Size'),
  success?: boolean(name='Success'),
  total?: int32(name='Total'),
}

model ListLocationPaiImageResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ListLocationPaiImageResponseBody(name='body'),
}

async function listLocationPaiImageWithOptions(request: ListLocationPaiImageRequest, runtime: Util.RuntimeOptions): ListLocationPaiImageResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.current)) {
    body['Current'] = request.current;
  }
  if (!Util.isUnset(request.jwtToken)) {
    body['JwtToken'] = request.jwtToken;
  }
  if (!Util.isUnset(request.size)) {
    body['Size'] = request.size;
  }
  if (!Util.isUnset(request.sort)) {
    body['Sort'] = request.sort;
  }
  if (!Util.isUnset(request.sortField)) {
    body['SortField'] = request.sortField;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ListLocationPaiImage',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listLocationPaiImage(request: ListLocationPaiImageRequest): ListLocationPaiImageResponse {
  var runtime = new Util.RuntimeOptions{};
  return listLocationPaiImageWithOptions(request, runtime);
}

model ListLocationServiceRequest {
  current?: int32(name='Current'),
  jwtToken?: string(name='JwtToken'),
  size?: int32(name='Size'),
  sort?: string(name='Sort'),
  sortField?: string(name='SortField'),
}

model ListLocationServiceResponseBody = {
  code?: string(name='Code'),
  current?: int32(name='Current'),
  data?: [ 
    {
      appId?: string(name='AppId'),
      expireTime?: string(name='ExpireTime'),
      gmtCreate?: string(name='GmtCreate'),
      gmtModified?: string(name='GmtModified'),
      id?: long(name='Id'),
      name?: string(name='Name'),
      note?: string(name='Note'),
      qps?: long(name='Qps'),
      startTime?: string(name='StartTime'),
      status?: string(name='Status'),
      svcState?: string(name='SvcState'),
    }
  ](name='Data'),
  errorName?: string(name='ErrorName'),
  httpCode?: int32(name='HttpCode'),
  message?: string(name='Message'),
  pages?: int32(name='Pages'),
  requestId?: string(name='RequestId'),
  size?: int32(name='Size'),
  success?: boolean(name='Success'),
  total?: int32(name='Total'),
}

model ListLocationServiceResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ListLocationServiceResponseBody(name='body'),
}

async function listLocationServiceWithOptions(request: ListLocationServiceRequest, runtime: Util.RuntimeOptions): ListLocationServiceResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.current)) {
    body['Current'] = request.current;
  }
  if (!Util.isUnset(request.jwtToken)) {
    body['JwtToken'] = request.jwtToken;
  }
  if (!Util.isUnset(request.size)) {
    body['Size'] = request.size;
  }
  if (!Util.isUnset(request.sort)) {
    body['Sort'] = request.sort;
  }
  if (!Util.isUnset(request.sortField)) {
    body['SortField'] = request.sortField;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ListLocationService',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listLocationService(request: ListLocationServiceRequest): ListLocationServiceResponse {
  var runtime = new Util.RuntimeOptions{};
  return listLocationServiceWithOptions(request, runtime);
}

model ListProjectRequest {
  bizUsage?: string(name='BizUsage'),
  current?: int32(name='Current'),
  jwtToken?: string(name='JwtToken'),
  size?: int32(name='Size'),
  sortField?: string(name='SortField'),
  status?: string(name='Status'),
  title?: string(name='Title'),
  type?: string(name='Type'),
  withSource?: boolean(name='WithSource'),
  withUser?: boolean(name='WithUser'),
}

model ListProjectResponseBody = {
  code?: string(name='Code'),
  current?: int32(name='Current'),
  data?: [ 
    {
      bizUsage?: string(name='BizUsage'),
      createTime?: string(name='CreateTime'),
      dataset?: {
        buildResultUrl?: map[string]any(name='BuildResultUrl'),
        coverUrl?: string(name='CoverUrl'),
        glbModelUrl?: string(name='GlbModelUrl'),
        modelUrl?: string(name='ModelUrl'),
        originResultUrl?: string(name='OriginResultUrl'),
        ossKey?: string(name='OssKey'),
        poseUrl?: string(name='PoseUrl'),
        previewUrl?: string(name='PreviewUrl'),
      }(name='Dataset'),
      ext?: string(name='Ext'),
      extInfo?: map[string]any(name='ExtInfo'),
      id?: string(name='Id'),
      intro?: string(name='Intro'),
      modifiedTime?: string(name='ModifiedTime'),
      source?: {
        clothes?: [ 
          {
            coverUrl?: string(name='CoverUrl'),
            name?: string(name='Name'),
            ossKey?: string(name='OssKey'),
            type?: string(name='Type'),
          }
        ](name='Clothes'),
        files?: [ 
          {
            coverUrl?: string(name='CoverUrl'),
            fileName?: string(name='FileName'),
            id?: string(name='Id'),
            size?: long(name='Size'),
            type?: string(name='Type'),
            url?: string(name='Url'),
          }
        ](name='Files'),
        ossKey?: string(name='OssKey'),
      }(name='Source'),
      status?: string(name='Status'),
      title?: string(name='Title'),
      type?: string(name='Type'),
      user?: {
        aliyunUid?: string(name='AliyunUid'),
        createTime?: string(name='CreateTime'),
        modifiedTime?: string(name='ModifiedTime'),
        nickname?: string(name='Nickname'),
      }(name='User'),
    }
  ](name='Data'),
  message?: string(name='Message'),
  pages?: int32(name='Pages'),
  requestId?: string(name='RequestId'),
  size?: int32(name='Size'),
  success?: boolean(name='Success'),
  total?: int32(name='Total'),
}

model ListProjectResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ListProjectResponseBody(name='body'),
}

async function listProjectWithOptions(request: ListProjectRequest, runtime: Util.RuntimeOptions): ListProjectResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.bizUsage)) {
    body['BizUsage'] = request.bizUsage;
  }
  if (!Util.isUnset(request.current)) {
    body['Current'] = request.current;
  }
  if (!Util.isUnset(request.jwtToken)) {
    body['JwtToken'] = request.jwtToken;
  }
  if (!Util.isUnset(request.size)) {
    body['Size'] = request.size;
  }
  if (!Util.isUnset(request.sortField)) {
    body['SortField'] = request.sortField;
  }
  if (!Util.isUnset(request.status)) {
    body['Status'] = request.status;
  }
  if (!Util.isUnset(request.title)) {
    body['Title'] = request.title;
  }
  if (!Util.isUnset(request.type)) {
    body['Type'] = request.type;
  }
  if (!Util.isUnset(request.withSource)) {
    body['WithSource'] = request.withSource;
  }
  if (!Util.isUnset(request.withUser)) {
    body['WithUser'] = request.withUser;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ListProject',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listProject(request: ListProjectRequest): ListProjectResponse {
  var runtime = new Util.RuntimeOptions{};
  return listProjectWithOptions(request, runtime);
}

model ListProjectsByDependencyIdRequest {
  dependencyProjectId?: long(name='DependencyProjectId'),
  jwtToken?: string(name='JwtToken'),
  mapUuid?: string(name='MapUuid'),
  withDataset?: boolean(name='WithDataset'),
  withSource?: boolean(name='WithSource'),
}

model ListProjectsByDependencyIdResponseBody = {
  code?: string(name='Code'),
  data?: [ 
    {
      bizUsage?: string(name='BizUsage'),
      buildDetail?: {
        completedTime?: string(name='CompletedTime'),
        errorMessage?: string(name='ErrorMessage'),
        estimatedDuration?: long(name='EstimatedDuration'),
        runningTime?: string(name='RunningTime'),
        submitTime?: string(name='SubmitTime'),
      }(name='BuildDetail'),
      createTime?: string(name='CreateTime'),
      dataset?: {
        buildResultUrl?: map[string]any(name='BuildResultUrl'),
        coverUrl?: string(name='CoverUrl'),
        glbModelUrl?: string(name='GlbModelUrl'),
        modelUrl?: string(name='ModelUrl'),
        originResultUrl?: string(name='OriginResultUrl'),
        ossKey?: string(name='OssKey'),
        poseUrl?: string(name='PoseUrl'),
        previewUrl?: string(name='PreviewUrl'),
      }(name='Dataset'),
      ext?: string(name='Ext'),
      id?: string(name='Id'),
      intro?: string(name='Intro'),
      modifiedTime?: string(name='ModifiedTime'),
      source?: {
        createTime?: string(name='CreateTime'),
        id?: string(name='Id'),
        modifiedTime?: string(name='ModifiedTime'),
        ossKey?: string(name='OssKey'),
        projectId?: long(name='ProjectId'),
        sourceFiles?: [ 
          {
            coverUrl?: string(name='CoverUrl'),
            fileName?: string(name='FileName'),
            id?: string(name='Id'),
            size?: long(name='Size'),
            type?: string(name='Type'),
            url?: string(name='Url'),
          }
        ](name='SourceFiles'),
      }(name='Source'),
      status?: string(name='Status'),
      title?: string(name='Title'),
      type?: string(name='Type'),
    }
  ](name='Data'),
  errorName?: string(name='ErrorName'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ListProjectsByDependencyIdResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ListProjectsByDependencyIdResponseBody(name='body'),
}

async function listProjectsByDependencyIdWithOptions(request: ListProjectsByDependencyIdRequest, runtime: Util.RuntimeOptions): ListProjectsByDependencyIdResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.dependencyProjectId)) {
    body['DependencyProjectId'] = request.dependencyProjectId;
  }
  if (!Util.isUnset(request.jwtToken)) {
    body['JwtToken'] = request.jwtToken;
  }
  if (!Util.isUnset(request.mapUuid)) {
    body['MapUuid'] = request.mapUuid;
  }
  if (!Util.isUnset(request.withDataset)) {
    body['WithDataset'] = request.withDataset;
  }
  if (!Util.isUnset(request.withSource)) {
    body['WithSource'] = request.withSource;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ListProjectsByDependencyId',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listProjectsByDependencyId(request: ListProjectsByDependencyIdRequest): ListProjectsByDependencyIdResponse {
  var runtime = new Util.RuntimeOptions{};
  return listProjectsByDependencyIdWithOptions(request, runtime);
}

model ListSourceFileRequest {
  jwtToken?: string(name='JwtToken'),
  projectId?: string(name='ProjectId'),
}

model ListSourceFileResponseBody = {
  code?: string(name='Code'),
  data?: {
    picList?: [ 
      {
        createTime?: string(name='CreateTime'),
        fileName?: string(name='FileName'),
        id?: string(name='Id'),
        modifiedTime?: string(name='ModifiedTime'),
        ossKey?: string(name='OssKey'),
        type?: string(name='Type'),
        url?: string(name='Url'),
      }
    ](name='PicList'),
    videoList?: [ 
      {
        createTime?: string(name='CreateTime'),
        fileName?: string(name='FileName'),
        id?: string(name='Id'),
        modifiedTime?: string(name='ModifiedTime'),
        ossKey?: string(name='OssKey'),
        type?: string(name='Type'),
        url?: string(name='Url'),
      }
    ](name='VideoList'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ListSourceFileResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ListSourceFileResponseBody(name='body'),
}

async function listSourceFileWithOptions(request: ListSourceFileRequest, runtime: Util.RuntimeOptions): ListSourceFileResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.jwtToken)) {
    query['JwtToken'] = request.jwtToken;
  }
  if (!Util.isUnset(request.projectId)) {
    query['ProjectId'] = request.projectId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListSourceFile',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listSourceFile(request: ListSourceFileRequest): ListSourceFileResponse {
  var runtime = new Util.RuntimeOptions{};
  return listSourceFileWithOptions(request, runtime);
}

model ListWorkflowResponseBody = {
  data?: {
    humanPose?: [ 
      {
        bizUsage?: string(name='BizUsage'),
        id?: long(name='Id'),
        name?: string(name='Name'),
        objectType?: string(name='ObjectType'),
        status?: long(name='Status'),
      }
    ](name='HumanPose'),
    mannequins?: [ 
      {
        bizUsage?: string(name='BizUsage'),
        id?: long(name='Id'),
        name?: string(name='Name'),
        objectType?: string(name='ObjectType'),
        status?: long(name='Status'),
      }
    ](name='Mannequins'),
    object?: [ 
      {
        bizUsage?: string(name='BizUsage'),
        id?: long(name='Id'),
        name?: string(name='Name'),
        objectType?: string(name='ObjectType'),
        status?: long(name='Status'),
      }
    ](name='Object'),
    scene?: [ 
      {
        bizUsage?: string(name='BizUsage'),
        id?: long(name='Id'),
        name?: string(name='Name'),
        objectType?: string(name='ObjectType'),
        status?: long(name='Status'),
      }
    ](name='Scene'),
  }(name='Data'),
  httpCode?: long(name='HttpCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ListWorkflowResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ListWorkflowResponseBody(name='body'),
}

async function listWorkflowWithOptions(runtime: Util.RuntimeOptions): ListWorkflowResponse {
  var req = new OpenApi.OpenApiRequest{};
  var params = new OpenApi.Params{
    action = 'ListWorkflow',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listWorkflow(): ListWorkflowResponse {
  var runtime = new Util.RuntimeOptions{};
  return listWorkflowWithOptions(runtime);
}

model LoginRequest {
  empId?: string(name='EmpId'),
  empName?: string(name='EmpName'),
  token?: string(name='Token'),
  type?: string(name='Type'),
}

model LoginResponseBody = {
  code?: string(name='Code'),
  data?: {
    jwtToken?: string(name='JwtToken'),
    nickname?: string(name='Nickname'),
    uid?: string(name='Uid'),
  }(name='Data'),
  errorName?: string(name='ErrorName'),
  httpCode?: int32(name='HttpCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model LoginResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: LoginResponseBody(name='body'),
}

async function loginWithOptions(request: LoginRequest, runtime: Util.RuntimeOptions): LoginResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.empId)) {
    body['EmpId'] = request.empId;
  }
  if (!Util.isUnset(request.empName)) {
    body['EmpName'] = request.empName;
  }
  if (!Util.isUnset(request.token)) {
    body['Token'] = request.token;
  }
  if (!Util.isUnset(request.type)) {
    body['Type'] = request.type;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'Login',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function login(request: LoginRequest): LoginResponse {
  var runtime = new Util.RuntimeOptions{};
  return loginWithOptions(request, runtime);
}

model PublishArEditProjectRequest {
  jwtToken?: string(name='JwtToken'),
  mapId?: long(name='MapId'),
}

model PublishArEditProjectResponseBody = {
  code?: string(name='Code'),
  data?: boolean(name='Data'),
  errorName?: string(name='ErrorName'),
  httpCode?: int32(name='HttpCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model PublishArEditProjectResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: PublishArEditProjectResponseBody(name='body'),
}

async function publishArEditProjectWithOptions(request: PublishArEditProjectRequest, runtime: Util.RuntimeOptions): PublishArEditProjectResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.jwtToken)) {
    body['JwtToken'] = request.jwtToken;
  }
  if (!Util.isUnset(request.mapId)) {
    body['MapId'] = request.mapId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'PublishArEditProject',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function publishArEditProject(request: PublishArEditProjectRequest): PublishArEditProjectResponse {
  var runtime = new Util.RuntimeOptions{};
  return publishArEditProjectWithOptions(request, runtime);
}

model QueryAreaMapRequest {
  id?: long(name='Id'),
  jwtToken?: string(name='JwtToken'),
}

model QueryAreaMapResponseBody = {
  code?: string(name='Code'),
  data?: {
    d3Oss?: string(name='D3Oss'),
    extInfo?: string(name='ExtInfo'),
    id?: long(name='Id'),
    locationOss?: string(name='LocationOss'),
    mapType?: string(name='MapType'),
    name?: string(name='Name'),
    note?: string(name='Note'),
    status?: string(name='Status'),
  }(name='Data'),
  errorName?: string(name='ErrorName'),
  httpCode?: int32(name='HttpCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model QueryAreaMapResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryAreaMapResponseBody(name='body'),
}

async function queryAreaMapWithOptions(request: QueryAreaMapRequest, runtime: Util.RuntimeOptions): QueryAreaMapResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.id)) {
    body['Id'] = request.id;
  }
  if (!Util.isUnset(request.jwtToken)) {
    body['JwtToken'] = request.jwtToken;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'QueryAreaMap',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryAreaMap(request: QueryAreaMapRequest): QueryAreaMapResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryAreaMapWithOptions(request, runtime);
}

model QueryBuildBreakpointRequest {
  jwtToken?: string(name='JwtToken'),
  projectId?: string(name='ProjectId'),
}

model QueryBuildBreakpointResponseBody = {
  code?: string(name='Code'),
  data?: {
    breakpoints?: [ 
      {
        algorithm?: string(name='Algorithm'),
        jobId?: string(name='JobId'),
      }
    ](name='Breakpoints'),
    projectId?: string(name='ProjectId'),
  }(name='Data'),
  errorName?: string(name='ErrorName'),
  httpCode?: int32(name='HttpCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model QueryBuildBreakpointResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryBuildBreakpointResponseBody(name='body'),
}

async function queryBuildBreakpointWithOptions(request: QueryBuildBreakpointRequest, runtime: Util.RuntimeOptions): QueryBuildBreakpointResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.jwtToken)) {
    body['JwtToken'] = request.jwtToken;
  }
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'QueryBuildBreakpoint',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryBuildBreakpoint(request: QueryBuildBreakpointRequest): QueryBuildBreakpointResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryBuildBreakpointWithOptions(request, runtime);
}

model QueryLocationServiceRequest {
  id?: long(name='Id'),
  jwtToken?: string(name='JwtToken'),
}

model QueryLocationServiceResponseBody = {
  code?: string(name='Code'),
  data?: {
    appId?: string(name='AppId'),
    expireTime?: string(name='ExpireTime'),
    gmtCreate?: string(name='GmtCreate'),
    gmtModified?: string(name='GmtModified'),
    id?: long(name='Id'),
    imageId?: long(name='ImageId'),
    imageName?: string(name='ImageName'),
    name?: string(name='Name'),
    note?: string(name='Note'),
    qps?: long(name='Qps'),
    startTime?: string(name='StartTime'),
    svcDeployStatus?: string(name='SvcDeployStatus'),
    svcState?: string(name='SvcState'),
    treeConfig?: string(name='TreeConfig'),
    uuidLogMap?: string(name='UuidLogMap'),
  }(name='Data'),
  errorName?: string(name='ErrorName'),
  httpCode?: int32(name='HttpCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model QueryLocationServiceResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryLocationServiceResponseBody(name='body'),
}

async function queryLocationServiceWithOptions(request: QueryLocationServiceRequest, runtime: Util.RuntimeOptions): QueryLocationServiceResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.id)) {
    body['Id'] = request.id;
  }
  if (!Util.isUnset(request.jwtToken)) {
    body['JwtToken'] = request.jwtToken;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'QueryLocationService',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryLocationService(request: QueryLocationServiceRequest): QueryLocationServiceResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryLocationServiceWithOptions(request, runtime);
}

model QueryProjectBuildDetailRequest {
  projectId?: string(name='ProjectId'),
}

model QueryProjectBuildDetailResponseBody = {
  code?: string(name='Code'),
  data?: {
    gmtCreate?: string(name='GmtCreate'),
    gmtModified?: string(name='GmtModified'),
    id?: long(name='Id'),
    instanceDetailResponseList?: [ 
      {
        gmtCreate?: string(name='GmtCreate'),
        gmtModified?: string(name='GmtModified'),
        id?: long(name='Id'),
        params?: string(name='Params'),
        status?: string(name='Status'),
        submitTime?: string(name='SubmitTime'),
        templateId?: long(name='TemplateId'),
      }
    ](name='InstanceDetailResponseList'),
    status?: string(name='Status'),
    title?: string(name='Title'),
    userId?: long(name='UserId'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model QueryProjectBuildDetailResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryProjectBuildDetailResponseBody(name='body'),
}

async function queryProjectBuildDetailWithOptions(request: QueryProjectBuildDetailRequest, runtime: Util.RuntimeOptions): QueryProjectBuildDetailResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.projectId)) {
    query['ProjectId'] = request.projectId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryProjectBuildDetail',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryProjectBuildDetail(request: QueryProjectBuildDetailRequest): QueryProjectBuildDetailResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryProjectBuildDetailWithOptions(request, runtime);
}

model QueryProjectDetailRequest {
  jwtToken?: string(name='JwtToken'),
  projectId?: string(name='ProjectId'),
}

model QueryProjectDetailResponseBody = {
  code?: string(name='Code'),
  data?: {
    bizUsage?: string(name='BizUsage'),
    buildDetail?: {
      completedTime?: string(name='CompletedTime'),
      errorMessage?: string(name='ErrorMessage'),
      estimatedDuration?: long(name='EstimatedDuration'),
      runningTime?: string(name='RunningTime'),
      submitTime?: string(name='SubmitTime'),
    }(name='BuildDetail'),
    createMode?: string(name='CreateMode'),
    createTime?: string(name='CreateTime'),
    dataset?: {
      buildResultUrl?: map[string]any(name='BuildResultUrl'),
      coverUrl?: string(name='CoverUrl'),
      createTime?: string(name='CreateTime'),
      deleted?: boolean(name='Deleted'),
      glbModelUrl?: string(name='GlbModelUrl'),
      id?: string(name='Id'),
      modelUrl?: string(name='ModelUrl'),
      modifiedTime?: string(name='ModifiedTime'),
      originResultUrl?: string(name='OriginResultUrl'),
      ossKey?: string(name='OssKey'),
      policy?: {
        accessId?: string(name='AccessId'),
        dir?: string(name='Dir'),
        expire?: string(name='Expire'),
        host?: string(name='Host'),
        policy?: string(name='Policy'),
        signature?: string(name='Signature'),
      }(name='Policy'),
      poseUrl?: string(name='PoseUrl'),
      previewUrl?: string(name='PreviewUrl'),
    }(name='Dataset'),
    deleted?: boolean(name='Deleted'),
    dependencies?: string(name='Dependencies'),
    id?: string(name='Id'),
    intro?: string(name='Intro'),
    modifiedTime?: string(name='ModifiedTime'),
    source?: {
      clothes?: [ 
        {
          coverUrl?: string(name='CoverUrl'),
          id?: string(name='Id'),
          name?: string(name='Name'),
          ossKey?: string(name='OssKey'),
          type?: string(name='Type'),
        }
      ](name='Clothes'),
      createTime?: string(name='CreateTime'),
      deleted?: boolean(name='Deleted'),
      files?: [ 
        {
          coverUrl?: string(name='CoverUrl'),
          fileName?: string(name='FileName'),
          id?: string(name='Id'),
          size?: long(name='Size'),
          type?: string(name='Type'),
          url?: string(name='Url'),
        }
      ](name='Files'),
      id?: string(name='Id'),
      modifiedTime?: string(name='ModifiedTime'),
      ossKey?: string(name='OssKey'),
      policy?: {
        accessId?: string(name='AccessId'),
        dir?: string(name='Dir'),
        expire?: string(name='Expire'),
        host?: string(name='Host'),
        policy?: string(name='Policy'),
        signature?: string(name='Signature'),
      }(name='Policy'),
    }(name='Source'),
    status?: string(name='Status'),
    title?: string(name='Title'),
    type?: string(name='Type'),
  }(name='Data'),
  errorName?: string(name='ErrorName'),
  httpCode?: int32(name='HttpCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model QueryProjectDetailResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryProjectDetailResponseBody(name='body'),
}

async function queryProjectDetailWithOptions(request: QueryProjectDetailRequest, runtime: Util.RuntimeOptions): QueryProjectDetailResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.jwtToken)) {
    query['JwtToken'] = request.jwtToken;
  }
  if (!Util.isUnset(request.projectId)) {
    query['ProjectId'] = request.projectId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryProjectDetail',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryProjectDetail(request: QueryProjectDetailRequest): QueryProjectDetailResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryProjectDetailWithOptions(request, runtime);
}

model RecognizeProductRegionsRequest {
  category?: int32(name='Category'),
  imageBase64?: string(name='ImageBase64'),
}

model RecognizeProductRegionsResponseBody = {
  code?: int32(name='Code'),
  data?: any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  resultCode?: string(name='ResultCode'),
  success?: string(name='Success'),
}

model RecognizeProductRegionsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: RecognizeProductRegionsResponseBody(name='body'),
}

async function recognizeProductRegionsWithOptions(request: RecognizeProductRegionsRequest, runtime: Util.RuntimeOptions): RecognizeProductRegionsResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.category)) {
    body['Category'] = request.category;
  }
  if (!Util.isUnset(request.imageBase64)) {
    body['ImageBase64'] = request.imageBase64;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'RecognizeProductRegions',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'Anonymous',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function recognizeProductRegions(request: RecognizeProductRegionsRequest): RecognizeProductRegionsResponse {
  var runtime = new Util.RuntimeOptions{};
  return recognizeProductRegionsWithOptions(request, runtime);
}

model RegisterUserResponseBody = {
  code?: string(name='Code'),
  errorName?: string(name='ErrorName'),
  httpCode?: int32(name='HttpCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model RegisterUserResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: RegisterUserResponseBody(name='body'),
}

async function registerUserWithOptions(runtime: Util.RuntimeOptions): RegisterUserResponse {
  var req = new OpenApi.OpenApiRequest{};
  var params = new OpenApi.Params{
    action = 'RegisterUser',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function registerUser(): RegisterUserResponse {
  var runtime = new Util.RuntimeOptions{};
  return registerUserWithOptions(runtime);
}

model ResumeLocationServiceRequest {
  id?: long(name='Id'),
  jwtToken?: string(name='JwtToken'),
}

model ResumeLocationServiceResponseBody = {
  code?: string(name='Code'),
  data?: boolean(name='Data'),
  errorName?: string(name='ErrorName'),
  httpCode?: int32(name='HttpCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ResumeLocationServiceResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ResumeLocationServiceResponseBody(name='body'),
}

async function resumeLocationServiceWithOptions(request: ResumeLocationServiceRequest, runtime: Util.RuntimeOptions): ResumeLocationServiceResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.id)) {
    body['Id'] = request.id;
  }
  if (!Util.isUnset(request.jwtToken)) {
    body['JwtToken'] = request.jwtToken;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ResumeLocationService',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function resumeLocationService(request: ResumeLocationServiceRequest): ResumeLocationServiceResponse {
  var runtime = new Util.RuntimeOptions{};
  return resumeLocationServiceWithOptions(request, runtime);
}

model SaveArEditProjectRequest {
  jwtToken?: string(name='JwtToken'),
  mapId?: long(name='MapId'),
}

model SaveArEditProjectResponseBody = {
  code?: string(name='Code'),
  data?: boolean(name='Data'),
  errorName?: string(name='ErrorName'),
  httpCode?: int32(name='HttpCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model SaveArEditProjectResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: SaveArEditProjectResponseBody(name='body'),
}

async function saveArEditProjectWithOptions(request: SaveArEditProjectRequest, runtime: Util.RuntimeOptions): SaveArEditProjectResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.jwtToken)) {
    body['JwtToken'] = request.jwtToken;
  }
  if (!Util.isUnset(request.mapId)) {
    body['MapId'] = request.mapId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'SaveArEditProject',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function saveArEditProject(request: SaveArEditProjectRequest): SaveArEditProjectResponse {
  var runtime = new Util.RuntimeOptions{};
  return saveArEditProjectWithOptions(request, runtime);
}

model SaveSourceRequest {
  jwtToken?: string(name='JwtToken'),
  projectId?: long(name='ProjectId'),
}

model SaveSourceResponseBody = {
  code?: string(name='Code'),
  errorName?: string(name='ErrorName'),
  httpCode?: int32(name='HttpCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model SaveSourceResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: SaveSourceResponseBody(name='body'),
}

async function saveSourceWithOptions(request: SaveSourceRequest, runtime: Util.RuntimeOptions): SaveSourceResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.jwtToken)) {
    query['JwtToken'] = request.jwtToken;
  }
  if (!Util.isUnset(request.projectId)) {
    query['ProjectId'] = request.projectId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'SaveSource',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function saveSource(request: SaveSourceRequest): SaveSourceResponse {
  var runtime = new Util.RuntimeOptions{};
  return saveSourceWithOptions(request, runtime);
}

model SearchProductsByImageRequest {
  category?: int32(name='Category'),
  imageBase64?: string(name='ImageBase64'),
  region?: {
    height?: int32(name='Height'),
    startX?: int32(name='StartX'),
    startY?: int32(name='StartY'),
    width?: int32(name='Width'),
  }(name='Region'),
}

model SearchProductsByImageShrinkRequest {
  category?: int32(name='Category'),
  imageBase64?: string(name='ImageBase64'),
  regionShrink?: string(name='Region'),
}

model SearchProductsByImageResponseBody = {
  code?: int32(name='Code'),
  data?: any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  resultCode?: string(name='ResultCode'),
  success?: string(name='Success'),
}

model SearchProductsByImageResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: SearchProductsByImageResponseBody(name='body'),
}

async function searchProductsByImageWithOptions(tmpReq: SearchProductsByImageRequest, runtime: Util.RuntimeOptions): SearchProductsByImageResponse {
  Util.validateModel(tmpReq);
  var request = new SearchProductsByImageShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.region)) {
    request.regionShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.region, 'Region', 'json');
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.category)) {
    body['Category'] = request.category;
  }
  if (!Util.isUnset(request.imageBase64)) {
    body['ImageBase64'] = request.imageBase64;
  }
  if (!Util.isUnset(request.regionShrink)) {
    body['Region'] = request.regionShrink;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'SearchProductsByImage',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'Anonymous',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function searchProductsByImage(request: SearchProductsByImageRequest): SearchProductsByImageResponse {
  var runtime = new Util.RuntimeOptions{};
  return searchProductsByImageWithOptions(request, runtime);
}

model SuspendLocationServiceRequest {
  id?: long(name='Id'),
  jwtToken?: string(name='JwtToken'),
}

model SuspendLocationServiceResponseBody = {
  code?: string(name='Code'),
  data?: boolean(name='Data'),
  errorName?: string(name='ErrorName'),
  httpCode?: int32(name='HttpCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model SuspendLocationServiceResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: SuspendLocationServiceResponseBody(name='body'),
}

async function suspendLocationServiceWithOptions(request: SuspendLocationServiceRequest, runtime: Util.RuntimeOptions): SuspendLocationServiceResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.id)) {
    body['Id'] = request.id;
  }
  if (!Util.isUnset(request.jwtToken)) {
    body['JwtToken'] = request.jwtToken;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'SuspendLocationService',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function suspendLocationService(request: SuspendLocationServiceRequest): SuspendLocationServiceResponse {
  var runtime = new Util.RuntimeOptions{};
  return suspendLocationServiceWithOptions(request, runtime);
}

model UpdateLocationServiceRequest {
  id?: long(name='Id'),
  jwtToken?: string(name='JwtToken'),
  note?: string(name='Note'),
  qps?: int32(name='Qps'),
  svcName?: string(name='SvcName'),
  svcState?: string(name='SvcState'),
}

model UpdateLocationServiceResponseBody = {
  code?: string(name='Code'),
  data?: boolean(name='Data'),
  errorName?: string(name='ErrorName'),
  httpCode?: int32(name='HttpCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model UpdateLocationServiceResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: UpdateLocationServiceResponseBody(name='body'),
}

async function updateLocationServiceWithOptions(request: UpdateLocationServiceRequest, runtime: Util.RuntimeOptions): UpdateLocationServiceResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.id)) {
    body['Id'] = request.id;
  }
  if (!Util.isUnset(request.jwtToken)) {
    body['JwtToken'] = request.jwtToken;
  }
  if (!Util.isUnset(request.note)) {
    body['Note'] = request.note;
  }
  if (!Util.isUnset(request.qps)) {
    body['Qps'] = request.qps;
  }
  if (!Util.isUnset(request.svcName)) {
    body['SvcName'] = request.svcName;
  }
  if (!Util.isUnset(request.svcState)) {
    body['SvcState'] = request.svcState;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'UpdateLocationService',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateLocationService(request: UpdateLocationServiceRequest): UpdateLocationServiceResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateLocationServiceWithOptions(request, runtime);
}

model UpdateLocationTreeRequest {
  id?: long(name='Id'),
  jwtToken?: string(name='JwtToken'),
  treeConfig?: string(name='TreeConfig'),
}

model UpdateLocationTreeResponseBody = {
  code?: string(name='Code'),
  data?: boolean(name='Data'),
  errorName?: string(name='ErrorName'),
  httpCode?: int32(name='HttpCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model UpdateLocationTreeResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: UpdateLocationTreeResponseBody(name='body'),
}

async function updateLocationTreeWithOptions(request: UpdateLocationTreeRequest, runtime: Util.RuntimeOptions): UpdateLocationTreeResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.id)) {
    body['Id'] = request.id;
  }
  if (!Util.isUnset(request.jwtToken)) {
    body['JwtToken'] = request.jwtToken;
  }
  if (!Util.isUnset(request.treeConfig)) {
    body['TreeConfig'] = request.treeConfig;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'UpdateLocationTree',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateLocationTree(request: UpdateLocationTreeRequest): UpdateLocationTreeResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateLocationTreeWithOptions(request, runtime);
}

model UpdateProjectRequest {
  autoBuild?: boolean(name='AutoBuild'),
  ext?: map[string]any(name='Ext'),
  intro?: string(name='Intro'),
  jwtToken?: string(name='JwtToken'),
  projectId?: string(name='ProjectId'),
  title?: string(name='Title'),
}

model UpdateProjectShrinkRequest {
  autoBuild?: boolean(name='AutoBuild'),
  extShrink?: string(name='Ext'),
  intro?: string(name='Intro'),
  jwtToken?: string(name='JwtToken'),
  projectId?: string(name='ProjectId'),
  title?: string(name='Title'),
}

model UpdateProjectResponseBody = {
  code?: string(name='Code'),
  errorName?: string(name='ErrorName'),
  httpCode?: int32(name='HttpCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model UpdateProjectResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: UpdateProjectResponseBody(name='body'),
}

async function updateProjectWithOptions(tmpReq: UpdateProjectRequest, runtime: Util.RuntimeOptions): UpdateProjectResponse {
  Util.validateModel(tmpReq);
  var request = new UpdateProjectShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.ext)) {
    request.extShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.ext, 'Ext', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.autoBuild)) {
    query['AutoBuild'] = request.autoBuild;
  }
  if (!Util.isUnset(request.extShrink)) {
    query['Ext'] = request.extShrink;
  }
  if (!Util.isUnset(request.intro)) {
    query['Intro'] = request.intro;
  }
  if (!Util.isUnset(request.jwtToken)) {
    query['JwtToken'] = request.jwtToken;
  }
  if (!Util.isUnset(request.projectId)) {
    query['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.title)) {
    query['Title'] = request.title;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateProject',
    version = '2022-11-11',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateProject(request: UpdateProjectRequest): UpdateProjectResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateProjectWithOptions(request, runtime);
}

